package main

import "fmt"

func main() {

	fmt.Println("数组-----------------")
	arrayTest()
	fmt.Println()
	arrayTest1()
	fmt.Println()
	arrayTest2()
	fmt.Println()
	fmt.Println("指针-----------------")
	pointerTest()
	fmt.Println()
	fmt.Println("结构体测试struct-----------------")
	structTest()
	fmt.Println()
	fmt.Println("切片slice-----------------")
	sliceTest()
	fmt.Println()
	fmt.Println("范围range-----------------")
	rangeTest()
	fmt.Println()
	fmt.Println("Map-----------------")
	maptest()
	fmt.Println()
	fmt.Println("递归-----------------")
	fmt.Printf("%d 的阶乘是 %d\n", 4, Factorial(uint64(4)))
	fmt.Println()
	fmt.Println("类型转换-----------------")
	changeData()
	fmt.Println()
	fmt.Println("接口-----------------")
}
func changeData() {
	var sum int = 17
	var count int = 5
	var mean float32
	mean = float32(sum) / float32(count)
	fmt.Printf("mean 的值为: %f\n", mean)
}

func Factorial(n uint64) (result uint64) {
	if n > 0 {
		result = n * Factorial(n-1)
		return result
	}
	return 1
}

//Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
//Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的
//如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对
func maptest() {
	///* 声明变量，默认 map 是 nil */
	var countryCapitalMap map[string]string /*创建集合 */
	///* 使用 make 函数 */如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对
	countryCapitalMap = make(map[string]string)
	/* map插入key - value对,各个国家对应的首都 */
	countryCapitalMap["France"] = "巴黎"
	countryCapitalMap["Italy"] = "罗马"
	countryCapitalMap["Japan"] = "东京"
	countryCapitalMap["India "] = "新德里"
	countryCapitalMap["American"] = "新德里"
	/*使用键输出地图值 */
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap[country])
	}

	/*查看元素在集合中是否存在 */
	capital, ok := countryCapitalMap["American"] /*如果确定是真实的,则存在,否则不存在 */
	/*fmt.Println(capital) */
	/*fmt.Println(ok) */
	if ok {
		fmt.Println("American 的首都是", ok, capital)
	} else {
		fmt.Println("American 的首都不存在")
	}

	/*删除元素*/
	delete(countryCapitalMap, "France")
	fmt.Println("法国条目被删除")
	fmt.Println("删除元素后地图")
	/*打印地图*/
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap[country])
	}
}

//	Go语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。
// 在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
func rangeTest() {
	//这是我们使用range去求一个slice的和。使用数组跟这个很类似
	nums := []int{2, 3, 4}
	sum := 0
	for _, num := range nums {
		sum += num
	}
	fmt.Println("sum:", sum)
	//在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
	for i, num := range nums {
		if num == 3 {
			fmt.Println("index:", i)
		}
	}
	//range也可以用在map的键值对上。
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}
	//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
	for i, c := range "go" {
		fmt.Println(i, c)
	}
}

/*
Go 语言切片是对数组的抽象。即可变数组
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，
可以追加元素，在追加时可能使切片的容量增大
*/
func sliceTest() {
	// len 是数组的长度并且也是切片的初始长度
	// 可以指定容量，其中capacity为可选参数。
	//var slice1 []type = make([]type, len,capacity)
	//slice1 := make([]type, len)
	//s :=[] int {1,2,3 }//直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
	//s := arr[:]//初始化切片s,是数组arr的引用
	//s := arr[startIndex:endIndex]//将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片
	//s := arr[startIndex:]//默认 endIndex 时将表示一直到arr的最后一个元素
	//s := arr[:endIndex]//默认 startIndex 时将表示从arr的第一个元素开始
	//s1 := s[startIndex:endIndex]//通过切片s初始化切片s1
	//s :=make([]int,len,cap)//通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片
	sliceCommon() //正常
	slicenil()    //空
	sslicesub()   //截取
	sliceappend() //追加
}

//正常切片
func sliceCommon() {
	var numbers = make([]int, 3, 5)
	printSlice(numbers)
}

//nil空切片
func slicenil() {
	var numbers []int
	printSlice(numbers)
	if numbers == nil {
		fmt.Printf("切片是空的")
	}
}

//截取切片
func sslicesub() {
	/* 创建切片 */
	numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	printSlice(numbers)
	/* 打印原始切片 */
	fmt.Println("numbers ==", numbers)
	/* 打印子切片从索引1(包含) 到索引4(不包含)*/
	fmt.Println("numbers[1:4] ==", numbers[1:4])
	/* 默认下限为 0*/
	fmt.Println("numbers[:3] ==", numbers[:3])
	/* 默认上限为 len(s)*/
	fmt.Println("numbers[4:] ==", numbers[4:])
	numbers1 := make([]int, 0, 5)
	printSlice(numbers1)
	/* 打印子切片从索引  0(包含) 到索引 2(不包含) */
	number2 := numbers[:2]
	printSlice(number2)
	/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
	number3 := numbers[2:5]
	printSlice(number3)
}

//追加切片和切片扩容
func sliceappend() {
	var numbers []int
	printSlice(numbers)
	/* 允许追加空切片 */
	numbers = append(numbers, 0)
	printSlice(numbers)
	/* 向切片添加一个元素 */
	numbers = append(numbers, 1)
	printSlice(numbers)
	/* 同时添加多个元素 */
	numbers = append(numbers, 2, 3, 4)
	printSlice(numbers)
	/* 创建切片 numbers1 是之前切片的两倍容量*/
	numbers1 := make([]int, len(numbers), (cap(numbers))*2)
	/* 拷贝 numbers 的内容到 numbers1 */
	copy(numbers1, numbers)
	printSlice(numbers1)
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

func structTest() {
	//也可以做全局变量
	type Books struct {
		title   string
		author  string
		subject string
		book_id int
	}
	// 创建一个新的结构体
	fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})
	// 也可以使用 key => value 格式
	fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})
	// 忽略的字段为 0 或 空
	fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})

	var Book1 Books /* 声明 Book1 为 Books 类型 */
	var Book2 Books /* 声明 Book2 为 Books 类型 */

	/* book 1 描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.book_id = 6495407

	/* book 2 描述 */
	Book2.title = "Python 教程"
	Book2.author = "www.runoob.com"
	Book2.subject = "Python 语言教程"
	Book2.book_id = 6495700

	/* 打印 Book1 信息 */
	fmt.Printf("Book 1 title : %s\n", Book1.title)
	fmt.Printf("Book 1 author : %s\n", Book1.author)
	fmt.Printf("Book 1 subject : %s\n", Book1.subject)
	fmt.Printf("Book 1 book_id : %d\n", Book1.book_id)

	/* 打印 Book2 信息 */
	fmt.Printf("Book 2 title : %s\n", Book2.title)
	fmt.Printf("Book 2 author : %s\n", Book2.author)
	fmt.Printf("Book 2 subject : %s\n", Book2.subject)
	fmt.Printf("Book 2 book_id : %d\n", Book2.book_id)

}

/**
语言指针
*/
func pointerTest() {
	//定义指针变量
	var ip *int /* 指向整型*/
	fmt.Printf("初始化的值: %x\n", ip)
	fmt.Print("空指针判断...")
	fmt.Println(ip == nil)
	//var fp *float32    /* 指向浮点型 */
	var a int = 10
	fmt.Printf("变量的值: %d\n", a)
	fmt.Printf("变量的地址: %x\n", &a)
	//指针变量存储
	ip = &a
	/* 指针变量的存储地址 */
	fmt.Printf("ip 变量储存的指针地址: %x\n", ip)
	/* 使用指针访问值 */
	fmt.Printf("*ip 变量的值: %d\n", *ip)
}

func arrayTest() {

	var numbers = [3]int{1, 2, 3}
	i1 := numbers[0]
	i2 := numbers[1]
	i3 := numbers[2]
	fmt.Print(i1, i2, i3)
	//重新赋值
	numbers[0] = 19
	i4 := numbers[0]
	fmt.Print(i4, i2, i3)

}
func arrayTest1() {

	var numbers = [...]int{1, 2, 3}
	//var numbers = []int{1, 2, 3}
	i1 := numbers[0]
	i2 := numbers[1]
	i3 := numbers[2]
	fmt.Print(i1, i2, i3)
}

//该变量的值将会是指定长度的、其中各元素均为元素类型的零值（或称默认值）的数组值。
func arrayTest2() {

	var numbers [5]int //等同于[5]int{0, 0, 0, 0, 0}
	i1 := numbers[0]
	i2 := numbers[1]
	i3 := numbers[2]
	fmt.Print(i1, i2, i3)
}
